rclone(1) rclone(1)

Rclone syncs your files to cloud storage

   • About rclone

   • What can rclone do for you?

   • What features does rclone have?

   • What providers does rclone support?

   • Download (https://rclone.org/downloads/)

   • Install (https://rclone.org/install/)

   • Donate. (https://rclone.org/donate/)

About rclone

   Rclone is a command-line program to manage files on cloud storage.  It is a feature-rich alternative
   to cloud vendors' web storage interfaces.  Over 40 cloud storage products support  rclone  including
   S3 object stores, business & consumer file storage services, as well as standard transfer protocols.

   Rclone has powerful cloud equivalents to the unix commands rsync, cp, mv, mount, ls, ncdu, tree, rm,
   and cat.  Rclone's familiar syntax includes shell pipeline support, and --dry-run protection.  It is
   used at the command line, in scripts or via its API.

   Users  call  rclone  "The Swiss army knife of cloud storage", and "Technology indistinguishable from
   magic".

   Rclone really looks after your data.  It preserves timestamps and verifies checksums at  all  times.
   Transfers  over  limited  bandwidth; intermittent connections, or subject to quota can be restarted,
   from the last good file transferred.  You can check (https://rclone.org/commands/rclone_check/)  the
   integrity  of  your  files.   Where possible, rclone employs server-side transfers to minimise local
   bandwidth use and transfers from one provider to another without using local disk.

   Virtual backends wrap local and cloud file systems to apply encryption  (https://rclone.org/crypt/),
   compression    (https://rclone.org/compress/),   chunking   (https://rclone.org/chunker/),   hashing
   (https://rclone.org/hasher/) and joining (https://rclone.org/union/).

   Rclone mounts (https://rclone.org/commands/rclone_mount/) any local, cloud or virtual filesystem  as
   a   disk   on   Windows,   macOS,   linux   and   FreeBSD,   and   also   serves   these  over  SFTP
   (https://rclone.org/commands/rclone_serve_sftp/),           HTTP            (https://rclone.org/com‐
   mands/rclone_serve_http/),     WebDAV     (https://rclone.org/commands/rclone_serve_webdav/),    FTP
   (https://rclone.org/commands/rclone_serve_ftp/)       and       DLNA        (https://rclone.org/com‐
   mands/rclone_serve_dlna/).

   Rclone   is   mature,   open-source  software  originally  inspired  by  rsync  and  written  in  Go
   (https://golang.org).  The friendly support community is familiar with varied use  cases.   Official
   Ubuntu,  Debian,  Fedora,  Brew and Chocolatey repos.  include rclone.  For the latest version down‐
   loading from rclone.org (https://rclone.org/downloads/) is recommended.

   Rclone is widely used on Linux, Windows and Mac.  Third-party developers create  innovative  backup,
   restore, GUI and business process solutions using the rclone command line or API.

   Rclone does the heavy lifting of communicating with cloud storage.

What can rclone do for you?

   Rclone helps you:

   • Backup (and encrypt) files to cloud storage

   • Restore (and decrypt) files from cloud storage

   • Mirror cloud data to other cloud services or locally

   • Migrate data to the cloud, or between cloud storage vendors

   • Mount multiple, encrypted, cached or diverse cloud storage as a disk

   • Analyse   and   account  for  data  held  on  cloud  storage  using  lsf  (https://rclone.org/com‐
     mands/rclone_lsf/),        ljson        (https://rclone.org/commands/rclone_lsjson/),         size
     (https://rclone.org/commands/rclone_size/), ncdu (https://rclone.org/commands/rclone_ncdu/)

   • Union  (https://rclone.org/union/)  file  systems  together to present multiple local and/or cloud
     file systems as one

Features

   • Transfers

     • MD5, SHA1 hashes are checked at all times for file integrity

     • Timestamps are preserved on files

     • Operations can be restarted at any time

     • Can be to and from network, e.g.  two different cloud providers

     • Can use multi-threaded downloads to local disk

   • Copy (https://rclone.org/commands/rclone_copy/) new or changed files to cloud storage

   • Sync (https://rclone.org/commands/rclone_sync/) (one way) to make a directory identical

   • Move (https://rclone.org/commands/rclone_move/) files to cloud storage deleting  the  local  after
     verification

   • Check (https://rclone.org/commands/rclone_check/) hashes and for missing/extra files

   • Mount (https://rclone.org/commands/rclone_mount/) your cloud storage as a network disk

   • Serve    (https://rclone.org/commands/rclone_serve/)    local    or   remote   files   over   HTTP
     (https://rclone.org/commands/rclone_serve_http/)/WebDav                   (https://rclone.org/com‐
     mands/rclone_serve_webdav/)/FTP               (https://rclone.org/commands/rclone_serve_ftp/)/SFTP
     (https://rclone.org/commands/rclone_serve_sftp/)/dlna                     (https://rclone.org/com‐
     mands/rclone_serve_dlna/)

   • Experimental Web based GUI (https://rclone.org/gui/)

Supported providers

   (There are many others, built on standard protocols such as WebDAV or S3, that work out of the box.)

   • 1Fichier

   • Akamai Netstorage

   • Alibaba Cloud (Aliyun) Object Storage System (OSS)

   • Amazon Drive

   • Amazon S3

   • Backblaze B2

   • Box

   • Ceph

   • China Mobile Ecloud Elastic Object Storage (EOS)

   • Citrix ShareFile

   • C14

   • DigitalOcean Spaces

   • Digi Storage

   • Dreamhost

   • Dropbox

   • Enterprise File Fabric

   • FTP

   • Google Cloud Storage

   • Google Drive

   • Google Photos

   • HDFS

   • HTTP

   • Hubic

   • Jottacloud

   • IBM COS S3

   • Koofr

   • Mail.ru Cloud

   • Memset Memstore

   • Mega

   • Memory

   • Microsoft Azure Blob Storage

   • Microsoft OneDrive

   • Minio

   • Nextcloud

   • OVH

   • OpenDrive

   • OpenStack Swift

   • Oracle Cloud Storage

   • ownCloud

   • pCloud

   • premiumize.me

   • put.io

   • QingStor

   • Rackspace Cloud Files

   • rsync.net

   • Scaleway

   • Seafile

   • Seagate Lyve Cloud

   • SeaweedFS

   • SFTP

   • Sia

   • StackPath

   • Storj

   • SugarSync

   • Tencent Cloud Object Storage (COS)

   • Uptobox

   • Wasabi

   • WebDAV

   • Yandex Disk

   • Zoho WorkDrive

   • The local filesystem

   Links

   • Home page (https://rclone.org/)

   • GitHub project page for source and bug tracker (https://github.com/rclone/rclone)

   • Rclone Forum (https://forum.rclone.org)

   • Downloads (https://rclone.org/downloads/)

Install

   Rclone is a Go program and comes as a single binary file.

Quickstart

   • Download (https://rclone.org/downloads/) the relevant binary.

   • Extract the rclone executable, rclone.exe on Windows, from the archive.

   • Run rclone config to setup.  See rclone config docs (https://rclone.org/docs/) for more details.

   • Optionally configure automatic execution.

   See below for some expanded Linux / macOS instructions.

   See the usage (https://rclone.org/docs/) docs for how to use rclone, or run rclone -h.

   Already  installed  rclone  can  be easily updated to the latest version using the rclone selfupdate
   (https://rclone.org/commands/rclone_selfupdate/) command.

Script installation

   To install rclone on Linux/macOS/BSD systems, run:

          curl https://rclone.org/install.sh | sudo bash

   For beta installation, run:

          curl https://rclone.org/install.sh | sudo bash -s beta

   Note that this script checks the version of rclone installed first  and  won't  re-download  if  not
   needed.

Linux installation from precompiled binary

   Fetch and unpack

          curl -O https://downloads.rclone.org/rclone-current-linux-amd64.zip
          unzip rclone-current-linux-amd64.zip
          cd rclone-*-linux-amd64

   Copy binary file

          sudo cp rclone /usr/bin/
          sudo chown root:root /usr/bin/rclone
          sudo chmod 755 /usr/bin/rclone

   Install manpage

          sudo mkdir -p /usr/local/share/man/man1
          sudo cp rclone.1 /usr/local/share/man/man1/
          sudo mandb

   Run rclone config to setup.  See rclone config docs (https://rclone.org/docs/) for more details.

          rclone config

macOS installation with brew

          brew install rclone

   NOTE:    This    version    of    rclone    will   not   support   mount   any   more   (see   #5373
   (https://github.com/rclone/rclone/issues/5373)).  If mounting is wanted on macOS, either  install  a
   precompiled binary or enable the relevant option when installing from source.

macOS installation from precompiled binary, using curl

   To avoid problems with macOS gatekeeper enforcing the binary to be signed and notarized it is enough
   to download with curl.

   Download the latest version of rclone.

          cd && curl -O https://downloads.rclone.org/rclone-current-osx-amd64.zip

   Unzip the download and cd to the extracted folder.

          unzip -a rclone-current-osx-amd64.zip && cd rclone-*-osx-amd64

   Move rclone to your $PATH.  You will be prompted for your password.

          sudo mkdir -p /usr/local/bin
          sudo mv rclone /usr/local/bin/

   (the mkdir command is safe to run, even if the directory already exists).

   Remove the leftover files.

          cd .. && rm -rf rclone-*-osx-amd64 rclone-current-osx-amd64.zip

   Run rclone config to setup.  See rclone config docs (https://rclone.org/docs/) for more details.

          rclone config

macOS installation from precompiled binary, using a web browser

   When downloading a binary with a web browser, the browser will set the macOS  gatekeeper  quarantine
   attribute.  Starting from Catalina, when attempting to run rclone, a pop-up will appear saying:

          “rclone” cannot be opened because the developer cannot be verified.
          macOS cannot verify that this app is free from malware.

   The simplest fix is to run

          xattr -d com.apple.quarantine rclone

Install with docker

   The  rclone maintains a docker image for rclone (https://hub.docker.com/r/rclone/rclone).  These im‐
   ages are autobuilt by docker hub from the rclone source based on a minimal Alpine linux image.

   The :latest tag will always point to the latest stable release.  You can use the :beta  tag  to  get
   the latest build from master.  You can also use version tags, e.g.  :1.49.1, :1.49 or :1.

          $ docker pull rclone/rclone:latest
          latest: Pulling from rclone/rclone
          Digest: sha256:0e0ced72671989bb837fea8e88578b3fc48371aa45d209663683e24cfdaa0e11
          ...
          $ docker run --rm rclone/rclone:latest version
          rclone v1.49.1
          - os/arch: linux/amd64
          - go version: go1.12.9

   There  are  a few command line options to consider when starting an rclone Docker container from the
   rclone image.

   • You need to mount the host rclone config dir at /config/rclone into the Docker container.  Due  to
     the fact that rclone updates tokens inside its config file, and that the update process involves a
     file rename, you need to mount the whole host rclone config dir, not just the single  host  rclone
     config file.

   • You need to mount a host data dir at /data into the Docker container.

   • By  default, the rclone binary inside a Docker container runs with UID=0 (root).  As a result, all
     files created in a run will have UID=0.  If your config and data files reside on the host  with  a
     non-root UID:GID, you need to pass these on the container start command line.

   • If  you  want to access the RC interface (either via the API or the Web UI), it is required to set
     the --rc-addr to :5572 in order to connect to it from outside the container.  An explanation about
     why  this is necessary is present here (https://web.archive.org/web/20200808071950/https://python‐
     speed.com/articles/docker-connection-refused/).

     • NOTE: Users running this container with the docker network set to host should probably set it to
       listen to localhost only, with 127.0.0.1:5572 as the value for --rc-addr

   • It  is  possible to use rclone mount inside a userspace Docker container, and expose the resulting
     fuse mount to the host.  The exact docker run options to  do  that  might  vary  slightly  between
     hosts.  See, e.g.  the discussion in this thread (https://github.com/moby/moby/issues/9448).

     You also need to mount the host /etc/passwd and /etc/group for fuse to work inside the container.

   Here are some commands tested on an Ubuntu 18.04.3 host:

          # config on host at ~/.config/rclone/rclone.conf
          # data on host at ~/data

          # make sure the config is ok by listing the remotes
          docker run --rm \
              --volume ~/.config/rclone:/config/rclone \
              --volume ~/data:/data:shared \
              --user $(id -u):$(id -g) \
              rclone/rclone \
              listremotes

          # perform mount inside Docker container, expose result to host
          mkdir -p ~/data/mount
          docker run --rm \
              --volume ~/.config/rclone:/config/rclone \
              --volume ~/data:/data:shared \
              --user $(id -u):$(id -g) \
              --volume /etc/passwd:/etc/passwd:ro --volume /etc/group:/etc/group:ro \
              --device /dev/fuse --cap-add SYS_ADMIN --security-opt apparmor:unconfined \
              rclone/rclone \
              mount dropbox:Photos /data/mount &
          ls ~/data/mount
          kill %1

Install from source

   Make   sure   you   have   at   least   Go  (https://golang.org/)  go1.15  installed.   Download  go
   (https://golang.org/dl/) if necessary.  The latest release is recommended.  Then

          git clone https://github.com/rclone/rclone.git
          cd rclone
          go build
          # If on macOS and mount is wanted, instead run: make GOTAGS=cmount
          ./rclone version

   This will leave you a checked out version of rclone you can modify and send pull requests with.   If
   you  use make instead of go build then the rclone build will have the correct version information in
   it.

   You can also build the latest stable rclone with:

          go get github.com/rclone/rclone

   or the latest version (equivalent to the beta) with

          go get github.com/rclone/rclone@master

   These will build the binary in $(go env GOPATH)/bin (~/go/bin/rclone by default)  after  downloading
   the  source  to  the go module cache.  Note - do not use the -u flag here.  This causes go to try to
   update the dependencies that rclone uses and sometimes these don't work with the current version  of
   rclone.

Installation with Ansible

   This  can  be done with Stefan Weichinger's ansible role (https://github.com/stefangweichinger/ansi‐
   ble-rclone).

   Instructions

   1. git clone https://github.com/stefangweichinger/ansible-rclone.git into your local roles-directory

   2. add the role to the hosts you want rclone installed to:

          - hosts: rclone-hosts
            roles:
                - rclone

Portable installation

   As mentioned above (https://rclone.org/install/#quickstart), rclone is single executable (rclone, or
   rclone.exe  on  Windows)  that you can download as a zip archive and extract into a location of your
   choosing.  When executing different commands, it may create files in different locations, such as  a
   configuration file and various temporary files.  By default the locations for these are according to
   your operating system, e.g.  configuration file in your user profile directory and  temporary  files
   in  the  standard temporary directory, but you can customize all of them, e.g.  to make a completely
   self-contained, portable installation.

   Run the config paths (https://rclone.org/commands/rclone_config_paths/) command to see the locations
   that rclone will use.

   To  override  them set the corresponding options (as command-line arguments, or as environment vari‐
   ables (https://rclone.org/docs/#environment-variables)): -  --config  (https://rclone.org/docs/#con‐
   fig-config-file)     -    --cache-dir    (https://rclone.org/docs/#cache-dir-dir)    -    --temp-dir
   (https://rclone.org/docs/#temp-dir-dir)

Autostart

   After installing and configuring rclone, as described above, you are ready to use rclone as  an  in‐
   teractive  command  line utility.  If your goal is to perform periodic operations, such as a regular
   sync (https://rclone.org/commands/rclone_sync/), you will probably want  to  configure  your  rclone
   command  in your operating system's scheduler.  If you need to expose service-like features, such as
   remote     control     (https://rclone.org/rc/),      GUI      (https://rclone.org/gui/),      serve
   (https://rclone.org/commands/rclone_serve/) or mount (https://rclone.org/commands/rclone_move/), you
   will often want an rclone command always running in the background, and configuring it to run  in  a
   service  infrastructure  may be a better option.  Below are some alternatives on how to achieve this
   on different operating systems.

   NOTE: Before setting up autorun it is highly recommended that you have tested your command  manually
   from a Command Prompt first.

Autostart on Windows

   The  most relevant alternatives for autostart on Windows are: - Run at user log on using the Startup
   folder - Run at user log on, at system startup or at schedule using Task Scheduler - Run  at  system
   startup using Windows service

Running in background

   Rclone  is  a  console  application,  so if not starting from an existing Command Prompt, e.g.  when
   starting rclone.exe from a shortcut, it will open a Command Prompt window.  When configuring  rclone
   to  run  from task scheduler and windows service you are able to set it to run hidden in background.
   From rclone version 1.54 you can also make it run hidden from anywhere by adding option --no-console
   (it  may still flash briefly when the program starts).  Since rclone normally writes information and
   any error messages to the console, you must redirect this to a file to be able to  see  it.   Rclone
   has a built-in option --log-file for that.

   Example command to run a sync in background:

          c:\rclone\rclone.exe sync c:\files remote:/files --no-console --log-file c:\rclone\logs\sync_files.txt

User account

   As  mentioned  in the mount (https://rclone.org/commands/rclone_move/) documentation, mounted drives
   created as Administrator are not visible to other accounts, not even the account that  was  elevated
   as  Administrator.  By running the mount command as the built-in SYSTEM user account, it will create
   drives accessible for everyone on the system.  Both scheduled task and Windows service can  be  used
   to achieve this.

   NOTE:  Remember  that when rclone runs as the SYSTEM user, the user profile that it sees will not be
   yours.  This means that if you normally run rclone with configuration file in the default  location,
   to  be  able to use the same configuration when running as the system user you must explicitely tell
   rclone where to find it with the --config (https://rclone.org/docs/#config-config-file)  option,  or
   else  it  will look in the system users profile path (C:\Windows\System32\config\systemprofile).  To
   test your command manually from a Command Prompt, you can run it with the  PsExec  (https://docs.mi‐
   crosoft.com/en-us/sysinternals/downloads/psexec)  utility from Microsoft's Sysinternals suite, which
   takes option -s to execute commands as the SYSTEM user.

Start from Startup folder

   To quickly execute an rclone command you can simply create a standard Windows Explorer shortcut  for
   the  complete  rclone  command you want to run.  If you store this shortcut in the special "Startup"
   start-menu folder, Windows will automatically run it at login.  To open this folder in  Windows  Ex‐
   plorer, enter path %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup, or C:\ProgramData\Micro‐
   soft\Windows\Start Menu\Programs\StartUp if you want the command to start for every user  that  logs
   in.

   This  is the easiest approach to autostarting of rclone, but it offers no functionality to set it to
   run as different user, or to set conditions or actions on certain events.  Setting  up  a  scheduled
   task as described below will often give you better results.

Start from Task Scheduler

   Task  Scheduler is an administrative tool built into Windows, and it can be used to configure rclone
   to be started automatically in a highly configurable way, e.g.  periodically on a schedule, on  user
   log  on,  or at system startup.  It can run be configured to run as the current user, or for a mount
   command that needs to be available to all users it can run as the SYSTEM user.  For technical infor‐
   mation, see https://docs.microsoft.com/windows/win32/taskschd/task-scheduler-start-page.

Run as service

   For  running  rclone  at  system startup, you can create a Windows service that executes your rclone
   command, as an alternative to scheduled task configured to run at startup.

Mount command built-in service integration

   For mount commands, Rclone has a built-in Windows service integration via the third-party WinFsp li‐
   brary  it  uses.   Registering  as  a  regular Windows service easy, as you just have to execute the
   built-in PowerShell command New-Service (requires administrative privileges).

   Example of a PowerShell command that creates a Windows service for mounting  some  remote:/files  as
   drive letter X:, for all users (service will be running as the local system account):

          New-Service -Name Rclone -BinaryPathName 'c:\rclone\rclone.exe mount remote:/files X: --config c:\rclone\config\rclone.conf --log-file c:\rclone\logs\mount.txt'

   The  WinFsp service infrastructure (https://github.com/billziss-gh/winfsp/wiki/WinFsp-Service-Archi‐
   tecture) supports incorporating services for file system implementations, such as rclone,  into  its
   own  launcher  service, as kind of "child services".  This has the additional advantage that it also
   implements a network provider that integrates into Windows standard  methods  for  managing  network
   drives.   This  is currently not officially supported by Rclone, but with WinFsp version 2019.3 B2 /
   v1.5B2  or  later   it   should   be   possible   through   path   rewriting   as   described   here
   (https://github.com/rclone/rclone/issues/3340).

Third-party service integration

   To   Windows   service   running   any  rclone  command,  the  excellent  third-party  utility  NSSM
   (http://nssm.cc), the "Non-Sucking Service Manager", can be used.  It includes  some  advanced  fea‐
   tures  such as adjusting process periority, defining process environment variables, redirect to file
   anything written to stdout, and customized response to different exit codes, with a GUI to configure
   everything from (although it can also be used from command line ).

   There  are  also  several  other  alternatives.  To mention one more, WinSW (https://github.com/win‐
   sw/winsw), "Windows Service Wrapper", is worth checking out.  It requires .NET Framework, but it  is
   preinstalled on newer versions of Windows, and it also provides alternative standalone distributions
   which includes necessary runtime (.NET 5).  WinSW is a command-line only utility, where you have  to
   manually create an XML file with service configuration.  This may be a drawback for some, but it can
   also be an advantage as it is easy to back up and re-use the configuration settings, without  having
   go through manual steps in a GUI.  One thing to note is that by default it does not restart the ser‐
   vice on error, one have to explicit enable this in the configuration file (via the  "onfailure"  pa‐
   rameter).

Autostart on Linux Start as a service

   To  always  run rclone in background, relevant for mount commands etc, you can use systemd to set up
   rclone as a system or user service.  Running as a system service ensures that it is run  at  startup
   even  if  the user it is running as has no active session.  Running rclone as a user service ensures
   that it only starts after the configured user has logged into the system.

Run periodically from cron

   To run a periodic command, such as a copy/sync, you can set up a cron job.

Usage

   Rclone  is  a  command  line  program  to  manage  files   on   cloud   storage.    After   download
   (https://rclone.org/downloads/)  and install, continue here to learn how to use it: Initial configu‐
   ration, what the basic syntax looks like, describes the various subcommands,  the  various  options,
   and more.

Configure

   First,  you'll  need  to configure rclone.  As the object storage systems have quite complicated au‐
   thentication these are kept in a config file.  (See the --config entry for how to  find  the  config
   file and choose its location.)

   The easiest way to make the config is to run rclone with the config option:

          rclone config

   See the following for detailed instructions for

   • 1Fichier (https://rclone.org/fichier/)

   • Akamai Netstorage (https://rclone.org/netstorage/)

   • Alias (https://rclone.org/alias/)

   • Amazon Drive (https://rclone.org/amazonclouddrive/)

   • Amazon S3 (https://rclone.org/s3/)

   • Backblaze B2 (https://rclone.org/b2/)

   • Box (https://rclone.org/box/)

   • Chunker (https://rclone.org/chunker/) - transparently splits large files for other remotes

   • Citrix ShareFile (https://rclone.org/sharefile/)

   • Compress (https://rclone.org/compress/)

   • Crypt (https://rclone.org/crypt/) - to encrypt other remotes

   • DigitalOcean Spaces (https://rclone.org/s3/#digitalocean-spaces)

   • Digi Storage (https://rclone.org/koofr/#digi-storage)

   • Dropbox (https://rclone.org/dropbox/)

   • Enterprise File Fabric (https://rclone.org/filefabric/)

   • FTP (https://rclone.org/ftp/)

   • Google Cloud Storage (https://rclone.org/googlecloudstorage/)

   • Google Drive (https://rclone.org/drive/)

   • Google Photos (https://rclone.org/googlephotos/)

   • Hasher (https://rclone.org/hasher/) - to handle checksums for other remotes

   • HDFS (https://rclone.org/hdfs/)

   • HTTP (https://rclone.org/http/)

   • Hubic (https://rclone.org/hubic/)

   • Jottacloud (https://rclone.org/jottacloud/)

   • Koofr (https://rclone.org/koofr/)

   • Mail.ru Cloud (https://rclone.org/mailru/)

   • Mega (https://rclone.org/mega/)

   • Memory (https://rclone.org/memory/)

   • Microsoft Azure Blob Storage (https://rclone.org/azureblob/)

   • Microsoft OneDrive (https://rclone.org/onedrive/)

   • OpenStack Swift / Rackspace Cloudfiles / Memset Memstore (https://rclone.org/swift/)

   • OpenDrive (https://rclone.org/opendrive/)

   • Pcloud (https://rclone.org/pcloud/)

   • premiumize.me (https://rclone.org/premiumizeme/)

   • put.io (https://rclone.org/putio/)

   • QingStor (https://rclone.org/qingstor/)

   • Seafile (https://rclone.org/seafile/)

   • SFTP (https://rclone.org/sftp/)

   • Sia (https://rclone.org/sia/)

   • Storj (https://rclone.org/storj/)

   • SugarSync (https://rclone.org/sugarsync/)

   • Union (https://rclone.org/union/)

   • Uptobox (https://rclone.org/uptobox/)

   • WebDAV (https://rclone.org/webdav/)

   • Yandex Disk (https://rclone.org/yandex/)

   • Zoho WorkDrive (https://rclone.org/zoho/)

   • The local filesystem (https://rclone.org/local/)